package com.jiepos.mpos.core.util;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.math.BigDecimal;
import java.security.MessageDigest;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
 * 
 * <p>标题: ——字符串处理工具类</p>
 * <p>模块: 通用平台</p>
 * <p>版权: Copyright (c) 2017 江苏杰博实信息技术有限公司
 * @author 娄伟峰
 * @version 1.0
 * @since 2017年9月11日 下午2:29:12
 * @history（历次修订内容、修订人、修订时间等）
 */
public class StringUtils {
	public final static Logger log = LoggerFactory.getLogger(StringUtils.class);
	 private static final int DEFAULT_BUFFER_SIZE = 8192;
	public static final String SLASH = getSlash();
	public static final String BACKSLASH = getBackslash();
	public static final String URL_SLASH = getURLSlash();
	public static final String BASE64_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

	private static final int[] wi = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10,
			5, 8, 4, 2, 1 };
	private static final int[] vi = { 1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2 };
	private static int[] ai = new int[18];
	//-------- 短信验证码生成策略----

	/** 纯数字验证码 */
	private static String NUMBER = "1234567890";

	/** 数字字母验证码(字符'o'不易识别，已剔除) */
	private static String NUMBERANTCHAR = "1234567890abcdefghijkmnpqrstuvwxyz";

	
	
	 // 全局数组
    private final static String[] strDigits = { "0", "1", "2", "3", "4", "5",
            "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };

  
    // 返回形式为数字跟字符串
    private static String byteToArrayString(byte bByte) {
        int iRet = bByte;
        // System.out.println("iRet="+iRet);
        if (iRet < 0) {
            iRet += 256;
        }
        int iD1 = iRet / 16;
        int iD2 = iRet % 16;
        return strDigits[iD1] + strDigits[iD2];
    }

    // 返回形式只为数字
    private static String byteToNum(byte bByte) {
        int iRet = bByte;
        System.out.println("iRet1=" + iRet);
        if (iRet < 0) {
            iRet += 256;
        }
        return String.valueOf(iRet);
    }

    // 转换字节数组为16进制字串
    private static String byteToString(byte[] bByte) {
        StringBuffer sBuffer = new StringBuffer();
        for (int i = 0; i < bByte.length; i++) {
            sBuffer.append(byteToArrayString(bByte[i]));
        }
        return sBuffer.toString();
    }

    /**
     * 判断字符串是否只包含英文或数字
     * @param strVal 字符串值
     * @return boolean true:只包含英文或数字 false:验证失败
     */
    public static boolean isChinese(String strVal){
    	String regex="^[\u4E00-\u9FA5]+$";
		Pattern pattern = Pattern.compile(regex);
		Matcher match = pattern.matcher(strVal);
		boolean b = match.matches();
		return b;    	
    }
    
	  /** 
     * double 相加 
     * @param d1 
     * @param d2 
     * @return 
     */ 
    public static double sum(double d1,double d2){ 
        BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
        BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
        return bd1.add(bd2).doubleValue(); 
    } 


    /** 
     * double 相减 
     * @param d1 
     * @param d2 
     * @return 
     */ 
    public static double sub(double d1,double d2){ 
        BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
        BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
        return bd1.subtract(bd2).doubleValue(); 
    } 

    /** 
     * double 乘法 
     * @param d1 
     * @param d2 
     * @return 
     */ 
    public static double mul(double d1,double d2){ 
        BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
        BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
        return bd1.multiply(bd2).doubleValue(); 
    } 


    /** 
     * double 除法 
     * @param d1 
     * @param d2 
     * @param scale 四舍五入 小数点位数 
     * @return 
     */ 
    public static double div(double d1,double d2,int scale){ 
        //  当然在此之前，你要判断分母是否为0，    
        //  为0你可以根据实际需求做相应的处理 

        BigDecimal bd1 = new BigDecimal(Double.toString(d1)); 
        BigDecimal bd2 = new BigDecimal(Double.toString(d2)); 
        return bd1.divide  
               (bd2,scale,BigDecimal.ROUND_HALF_UP).doubleValue(); 
    } 
    
    public static String objToString(Object obj){
    	if(obj != null && !String.valueOf(obj).equals("") && !String.valueOf(obj).equals("null")){
    		return String.valueOf(obj);
    	}else{
    		return "";
    	}
    }
    
    public static String objToNumberStr(Object obj){
    	if(obj != null && !String.valueOf(obj).equals("") && !String.valueOf(obj).equals("null")){
    		return String.valueOf(obj);
    	}else{
    		return "0.00";
    	}
    }
   
	/**
	 * 去除字符串换行和两边空格
	 * 
	 * @param src
	 *            设置原字符串
	 * @return String 返回结果
	 */
	public static String trim(String src) {
		if(isBlank(src)){
			return "";
		}
		return src.trim();
	}
	
	/**
	 * 替换回车换行
	 * @param src 源串
	 * @return
	 */
	public static String trimEnter(String src) {
		if(isBlank(src)){
			return "";
		}
		return src.replaceAll("(\r?\n)*", "");
	}

	 /**
    * 将指定输入流的所有文本全部读出到一个字符串中.
    *
    * @param in 要读取的输入流
    *
    * @return 从输入流中取得的文本
    *
    * @throws IOException 输入输出异常
    */
   public static String readText(InputStream in) throws IOException {
       return readText(in, null, -1);
   }

   /**
    * 将指定输入流的所有文本全部读出到一个字符串中.
    *
    * @param in 要读取的输入流
    * @param encoding 文本编码方式
    *
    * @return 从输入流中取得的文本
    *
    * @throws IOException 输入输出异常
    */
   public static String readText(InputStream in, String encoding) throws IOException {
       return readText(in, encoding, -1);
   }

   /**
    * 将指定输入流的所有文本全部读出到一个字符串中.
    *
    * @param in 要读取的输入流
    * @param encoding 文本编码方式
    * @param bufferSize 缓冲区大小(字符数)
    *
    * @return 从输入流中取得的文本
    *
    * @throws IOException 输入输出异常
    */
   public static String readText(InputStream in, String encoding, int bufferSize)
                                                                                 throws IOException {
       Reader reader = (encoding == null) ? new InputStreamReader(in) : new InputStreamReader(in,
           encoding);

       return readText(reader, bufferSize);
   }

   /**
    * 将指定<code>Reader</code>的所有文本全部读出到一个字符串中.
    *
    * @param reader 要读取的<code>Reader</code>
    *
    * @return 从<code>Reader</code>中取得的文本
    *
    * @throws IOException 输入输出异常
    */
   public static String readText(Reader reader) throws IOException {
       return readText(reader, -1);
   }

   /**
    * 将指定<code>Reader</code>的所有文本全部读出到一个字符串中.
    *
    * @param reader 要读取的<code>Reader</code>
    * @param bufferSize 缓冲区的大小(字符数)
    *
    * @return 从<code>Reader</code>中取得的文本
    *
    * @throws IOException 输入输出异常
    */
   public static String readText(Reader reader, int bufferSize) throws IOException {
       StringWriter writer = new StringWriter();

       io(reader, writer, bufferSize);
       return writer.toString();
   }
	
   /**
    * 从输入流读取内容, 写入到输出流中.  此方法使用大小为8192字节的默认的缓冲区.
    *
    * @param in 输入流
    * @param out 输出流
    *
    * @throws IOException 输入输出异常
    */
   public static void io(InputStream in, OutputStream out) throws IOException {
       io(in, out, -1);
   }

   /**
    * 从输入流读取内容, 写入到输出流中.  使用指定大小的缓冲区.
    *
    * @param in 输入流
    * @param out 输出流
    * @param bufferSize 缓冲区大小(字节数)
    *
    * @throws IOException 输入输出异常
    */
   public static void io(InputStream in, OutputStream out, int bufferSize) throws IOException {
       if (bufferSize == -1) {
           bufferSize = DEFAULT_BUFFER_SIZE;
       }

       byte[] buffer = new byte[bufferSize];
       int amount;

       while ((amount = in.read(buffer)) >= 0) {
           out.write(buffer, 0, amount);
       }
   }

   /**
    * 从输入流读取内容, 写入到输出流中.  此方法使用大小为4096字符的默认的缓冲区.
    *
    * @param in 输入流
    * @param out 输出流
    *
    * @throws IOException 输入输出异常
    */
   public static void io(Reader in, Writer out) throws IOException {
       io(in, out, -1);
   }

   /**
    * 从输入流读取内容, 写入到输出流中.  使用指定大小的缓冲区.
    *
    * @param in 输入流
    * @param out 输出流
    * @param bufferSize 缓冲区大小(字符数)
    *
    * @throws IOException 输入输出异常
    */
   public static void io(Reader in, Writer out, int bufferSize) throws IOException {
       if (bufferSize == -1) {
           bufferSize = DEFAULT_BUFFER_SIZE >> 1;
       }

       char[] buffer = new char[bufferSize];
       int amount;

       while ((amount = in.read(buffer)) >= 0) {
           out.write(buffer, 0, amount);
       }
   }
   /**
    * 检查字符串是否是空白：<code>null</code>、空字符串<code>""</code>或只有空白字符。
    * <pre>
    * StringUtil.isBlank(null)      = true
    * StringUtil.isBlank("")        = true
    * StringUtil.isBlank(" ")       = true
    * StringUtil.isBlank("bob")     = false
    * StringUtil.isBlank("  bob  ") = false
    * </pre>
    *
    * @param str 要检查的字符串
    *
    * @return 如果为空白, 则返回<code>true</code>
    */
   public static boolean isBlank(String str) {
       int length;
       if ((str == null) || ((length = str.length()) == 0) || str.equals("null")) {
           return true;
       }
       for (int i = 0; i < length; i++) {
           if (!Character.isWhitespace(str.charAt(i))) {
               return false;
           }
       }
       return true;
   }
   
   public static boolean isNotBlank(String str) {
       return !isBlank(str);
   }
	/**
	 * 返回“/”
	 * 
	 * @return 返回“/”
	 */
	public static String getSlash() {
		return "/";
	}

	/**
	 * 返回“\\”
	 * 
	 * @return 返回“\\”
	 */
	public static String getBackslash() {
		return "\\";
	}

	/**
	 * 返回“//”
	 * 
	 * @return 返回“//”
	 */
	public static String getURLSlash() {
		return "//";
	}

	/**
	 * 返回网页的空符号“&nbsp;”
	 * 
	 * @return 返回网页的空符号“&nbsp;”
	 */
	public static String getHTMLBlank() {
		return "&nbsp;";
	}

	/**
	 * 判断字符串是否为空
	 * 
	 * @param string
	 *            设置字符串
	 * @return boolean 返回是否为空
	 */
	public static boolean isEmpty(String string) {
		return string == null || string.length() == 0;
	}

	/**
	 * 判断两个字符串是否值相等
	 * 
	 * @param a
	 *            设置第一个字符串
	 * @param b
	 *            设置第二个字符串
	 * @return boolean 返回比较的结果
	 */
	public static boolean compare(String a, String b) {
		if (isEmpty(a) && isEmpty(b))
			return true;
		if (!isEmpty(a) && !isEmpty(b))
			return a.equals(b);
		else
			return false;
	}

	/**
	 * 判断两个字符串是否值相等，忽略大小写
	 * 
	 * @param a
	 *            设置第一个字符串
	 * @param b
	 *            设置第二个字符串
	 * @return boolean 返回比较的结果
	 */
	public static boolean compareIgnoreCase(String a, String b) {
		if (isEmpty(a) && isEmpty(b))
			return true;
		if (!isEmpty(a) && !isEmpty(b))
			return a.equalsIgnoreCase(b);
		else
			return false;
	}

	/**
	 * 复制字符串中从开始到指定的位置
	 * 
	 * @param src
	 *            设置字符串
	 * @param len
	 *            指定复制到某个位置
	 * @return String 返回结果
	 */
	public static String copy(String src, int len) {
		if (src == null)
			return null;
		if (src.length() > len)
			return len <= 0 ? null : src.substring(0, len);
		else
			return src;
	}

	/**
	 * 删除字符串中指定的一段字符串内容
	 * 
	 * @param src
	 *            设置原字符串
	 * @param delStr
	 *            设置需要删除的字符串
	 * @return String 返回结果
	 */
	public static String delete(String src, String delStr) {
		if (isEmpty(src) || isEmpty(delStr))
			return src;
		StringBuffer buffer = new StringBuffer(src);
		for (int index = src.length(); (index = src.lastIndexOf(delStr, index)) >= 0; index -= delStr
				.length())
			buffer.delete(index, index + delStr.length());

		return buffer.toString();
	}

	/**
	 * 将指定的字符和位置插入到原字符串中
	 * 
	 * @param src
	 *            设置原字符串
	 * @param anotherStr
	 *            设置需要插入的字符串
	 * @param offset
	 *            位置
	 * @return String 返回结果
	 */
	public static String insert(String src, String anotherStr, int offset) {
		if (isEmpty(src) || isEmpty(anotherStr))
			return src;
		StringBuffer buffer = new StringBuffer(src);
		if (offset >= 0 && offset <= src.length())
			buffer.insert(offset, anotherStr);
		return buffer.toString();
	}

	/**
	 * 根据参数替换字符串内容功能
	 * 
	 * @param src
	 *            设置原字符串
	 * @param oldStr
	 *            指定替换字符串
	 * @param newStr
	 *            将要替换的内容
	 * @param isCaseSensitive
	 *            是否区分大小写
	 * @return String 返回结果
	 */
	public static String replace(String src, String oldStr, String newStr,
			boolean isCaseSensitive) {
		if (isEmpty(src) || isEmpty(oldStr) || newStr == null)
			return src;
		String s = isCaseSensitive ? src : src.toLowerCase();
		String o = isCaseSensitive ? oldStr : oldStr.toLowerCase();
		StringBuffer buffer = new StringBuffer(src);
		for (int index = s.length(); (index = s.lastIndexOf(o, index)) >= 0; index -= o
				.length())
			buffer.replace(index, index + o.length(), newStr);

		return buffer.toString();
	}

	/**
	 * 根据参数替换字符串内容功能，可指定位置
	 * 
	 * @param src
	 *            设置原字符串
	 * @param oldStr
	 *            指定替换字符串
	 * @param newStr
	 *            将要替换的内容
	 * @param isCaseSensitive
	 *            是否区分大小写
	 * @param index
	 *            指定位置
	 * @return String 返回结果
	 */
	public static String replace(String src, String oldStr, String newStr,
			boolean isCaseSensitive, int index) {
		if (src == null || src.length() == 0 || oldStr == null
				|| oldStr.length() == 0 || index <= 0)
			return src;
		if (newStr == null)
			newStr = "";
		String s = isCaseSensitive ? src : src.toLowerCase();
		String o = isCaseSensitive ? oldStr : oldStr.toLowerCase();
		StringBuffer buffer = new StringBuffer(src);
		int length = o.length();
		int pos;
		for (pos = s.indexOf(o, 0); pos >= 0; pos = s.indexOf(o, pos + length))
			if (--index == 0)
				break;

		if (pos >= 0 && index == 0)
			buffer.replace(pos, pos + length, newStr);
		return buffer.toString();
	}

	/**
	 * 获取指定符号分割的字符串数组
	 * 
	 * @param src
	 *            设置原字符串
	 * @param delimiter
	 *            设置分割符号
	 * @return String[] 返回字符串数组
	 */
	public static String[] split(String src, String delimiter) {
		return isEmpty(src) ? new String[0] : src.split(delimiter);
	}

	/**
	 * 将指定字符串内容反转
	 * 
	 * @param str
	 *            设置原字符串
	 * @return String 返回字符串
	 */
	public static String reverse(String str) {
		return isEmpty(str) ? str : new StringBuffer(str).reverse().toString();
	}

	/**
	 * 给传入的字符串前后加双引号
	 * 
	 * @param str
	 *            设置原字符串
	 * @return String 返回结果
	 */
	public static String quote(String str) {
		if (isEmpty(str))
			return "\"\"";
		StringBuffer buffer = new StringBuffer(str);
		if (!str.startsWith("\""))
			buffer.insert(0, "\"");
		if (!str.endsWith("\""))
			buffer.append("\"");
		return buffer.toString();
	}

	/**
	 * 去除字符串中的双引号
	 * 
	 * @param str
	 *            设置原字符串
	 * @return String 返回结果
	 */
	public static String extractQuotedStr(String str) {
		if (isEmpty(str))
			return str;
		StringBuffer buffer = new StringBuffer(str);
		int index = str.length();
		while (buffer.charAt(buffer.length() - 1) == '"') {
			buffer.deleteCharAt(buffer.length() - 1);
			index = buffer.length();
			if (index <= 0)
				break;
		}
		if (buffer.length() == 0)
			return "";
		while (buffer.charAt(0) == '"') {
			buffer.deleteCharAt(0);
			index = buffer.length();
			if (index <= 0)
				break;
		}
		return buffer.toString();
	}

	/**
	 * 截取字符串中到指定的字符的内容，从左边开始
	 * 
	 * @param str
	 *            设置原字符串
	 * @param c
	 *            设置指定字符
	 * @return String 返回结果
	 */
	public static String strLChar(String str, char c) {
		if (str == null || str.length() == 0)
			return null;
		for (int i = 0; i < str.length(); i++)
			if (str.charAt(i) == c)
				return str.substring(0,i);

		return null;
	}

	/**
	 * 截取字符串中到指定的字符的内容，从右边开始
	 * 
	 * @param str
	 *            设置原字符串
	 * @param c
	 *            设置指定字符
	 * @return String 返回结果
	 */
	public static String strRChar(String str, char c) {
		if (str == null || str.length() == 0)
			return null;
		for (int i = str.length() - 1; i >= 0; i--)
			if (str.charAt(i) == c)
				return str.substring(i+1);

		return null;
	}

	/**
	 * 将Object对象数组转成字符串数组
	 * 
	 * @param array
	 *            设置Object对象数组
	 * @return String[] 返回结果
	 */
	public static String[] toArray(Object array[]) {
		if (array == null || array.length == 0)
			return null;
		String result[] = new String[array.length];
		for (int i = 0; i < array.length; i++)
			if (array[i] != null)
				result[i] = array[i].toString();

		return result;
	}
	
	/**
	 * 将object数组转换成list集合
	 * @param obj
	 * @return
	 */
	public static List objToArray(Object[] obj){
		if(obj == null || obj.length == 0){
			return null;			
		}
		List list = new ArrayList();
		for (int i = 0; i < obj.length; i++){
			list.add(obj[i]);
		}
		return list;
	}

	/**
	 * 将Vector对象数组元素转成字符串数组
	 * 
	 * @param list
	 *            设置Vector对象数组
	 * @return String[] 返回结果
	 */
	public static String[] toArray(Vector list) {
		if (list == null || list.size() == 0)
			return null;
		String result[] = new String[list.size()];
		for (int i = 0; i < list.size(); i++) {
			Object obj = list.get(i);
			if (obj != null)
				result[i] = list.get(i).toString();
		}

		return result;
	}

	/**
	 * 将字符串数组复制到LIST中
	 * 
	 * @param array
	 *            设置字符串数组
	 * @param list
	 *            设置LIST集合对象
	 * @param index
	 *            设置复制到LIST位置
	 * @return List 返回结果
	 */
	public static List copyToList(String array[], List list, int index) {
		if (array == null || array.length == 0)
			return list;
		if (list == null || index < 0)
			return list;
		for (int i = 0; i < array.length; i++)
			if (list.size() <= i + index)
				list.add(index + i, array[i]);
			else
				list.set(index + i, array[i]);

		return list;
	}
	
	/**
	 * 判断源字段串中是否包含目的字段串
	 * @param src 源字符串
	 * @param tar 目的字符串
	 * @return
	 */
	public static boolean contains(String src, String tar) {
		if (src == null || tar == null) {
			return false;
		}
		return src.indexOf(tar) == -1 ? false : true;
	}

	/**
	 * 判断字符串数组是否包含指定字符串
	 * 
	 * @param array
	 *            设置字符串数组
	 * @param str
	 *            设置批量字符串
	 * @return boolean 返回结果
	 */
	public static boolean contains(Object array[], String str) {
		if (array == null || array.length == 0)
			return false;
		if (str == null)
			return false;
		for (int i = 0; i < array.length; i++) {
			Object obj = array[i];
			if (obj != null && str.equals(obj.toString()))
				return true;
		}

		return false;
	}

	/**
	 * 获取字符串数组包含指定字符串的位置
	 * 
	 * @param array
	 *            设置字符串数组
	 * @param str
	 *            设置批量字符串
	 * @return int 返回结果
	 */
	public static int indexOf(Object array[], String str) {
		if (array == null || array.length == 0)
			return -1;
		if (str == null)
			return -1;
		for (int i = 0; i < array.length; i++) {
			Object obj = array[i];
			if (obj != null && str.equals(obj.toString()))
				return i;
		}

		return -1;
	}

	/**
	 * 验证是否为电子邮件格式
	 * 
	 * @param theEmail
	 *            设置电子邮件地址字符串
	 * @return boolean 返回是否合法
	 */
	public static boolean isEmail(String src) {
		if(isBlank(src)){
			return false;
		}
		return src.matches("^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$");
	}
	
	/**
	 * 验证是否为数字
	 * @param src
	 * @return
	 */
	public static boolean isNum(String src) {
		if(isBlank(src)){
			return false;
		}
		return src.matches("\\d+");
	}
 
	

	/**
	 * 实现判断字符串是否在数组中存在
	 * 
	 * @param strs
	 *            设置字符串数组
	 * @param str
	 *            设置要查找的字符串
	 * @param caseSensitive
	 *            设置是否区分大小写
	 * @return boolean 返回结果
	 */
	public static boolean strInArray(String strs[], String str,
			boolean caseSensitive) {
		if (strs != null && strs.length > 0) {
			for (int i = 0; i < strs.length; i++) {
				if (caseSensitive) {
					if (strs[i].equals(str))
						return true;
				} else {
					if (strs[i].equalsIgnoreCase(str))
						return true;
				}
			}
		}

		return false;
	}

	/**
	 * 验证身份证的合法性
	 * 
	 * @param idcard
	 *            设置身份证字符串
	 * @return boolean 返回结果
	 */
	public static boolean idCardVerify(String idcard) {
		if (idcard.length() == 15) {
			idcard = idCardUptoeighteen(idcard);
		}
		if (idcard.length() != 18) {
			return false;
		}
		String verify = idcard.substring(17, 18);
		if (verify.equals(getIdCardVerify(idcard))) {
			return true;
		}
		return false;
	}

	/**
	 * 获得身份证的合法性
	 * 
	 * @param eightcardid
	 *            设置身份证字符串
	 * @return String 返回结果
	 */
	public static String getIdCardVerify(String eightcardid) {
		int remaining = 0;
		if (eightcardid.length() == 18) {
			eightcardid = eightcardid.substring(0, 17);
		}
		if (eightcardid.length() == 17) {
			int sum = 0;
			for (int i = 0; i < 17; i++) {
				String k = eightcardid.substring(i, i + 1);
				ai[i] = Integer.parseInt(k);
			}
			for (int i = 0; i < 17; i++) {
				sum = sum + wi[i] * ai[i];
			}
			remaining = sum % 11;
		}
		return remaining == 2 ? "X" : String.valueOf(vi[remaining]);
	}

	/**
	 * 获得身份证15转18位
	 * 
	 * @param fifteencardid
	 *            设置身份证字符串
	 * @return String 返回结果
	 */
	public static String idCardUptoeighteen(String fifteencardid) {
		if (fifteencardid.length() != 15)
			return null;
		String eightcardid = fifteencardid.substring(0, 6);
		eightcardid = eightcardid + "19";
		eightcardid = eightcardid + fifteencardid.substring(6, 15);
		eightcardid = eightcardid + getIdCardVerify(eightcardid);
		return eightcardid;
	}

	/**
	 * 验证电话号码合法格式，格式为02584555112
	 * 
	 * @param phoneCode
	 *            设置电话号码字符串
	 * @return boolean 返回结果
	 */
	public static boolean isPhoneNum(String phoneCode) {
		Pattern p = Pattern.compile("[0][1-9]{2,3}[1-9]{6,8}");
		Matcher m = p.matcher(phoneCode);
		boolean b = m.matches();
		return b;
	}

	/**
	 * 字符数组转换为字符串,用逗号隔开
	 * 
	 * @param str
	 * @return String
	 */
	public static String arrayToString(final String[] str) {
		if (str == null)
			return "";
		StringBuffer rStr = new StringBuffer("");
		for (int i = 0; i < str.length; i++) {
			rStr.append(str[i]);
			rStr.append(",");
		}
		// 截取逗号
		if (rStr.toString().length() > 0) {
			rStr.setLength(rStr.length() - 1);
		}
		return rStr.toString();
	}



	/**
	 * 字符串的字符集类型转换
	 * 
	 * @param src
	 *            需要转换的字符串
	 * @param fromCharSet
	 *            字符串当前的字符集类型，如"iso-8859-1","GBK"等
	 * @param toCharSet
	 *            目标字符集类型，如"iso-8859-1","GBK"等
	 * @return 转换后的字符串,失败返回null
	 */
	public static String charSetConvert(String src, String fromCharSet,
			String toCharSet) {
		if (src == null)
			return src;
		try {
			return new String(src.getBytes(fromCharSet), toCharSet);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 将iso8859的字符集转换成UTF-8字符集
	 * 
	 * @param src
	 *            iso8859字符串
	 * @return 转化后的字符串,失败返回null
	 */
	public static String isoToUTF8(String src) {
		return charSetConvert(src, "iso-8859-1", "UTF-8");
	}

	/**
	 * 将iso8859的字符集转换成GBK字符集
	 * 
	 * @param src
	 *            iso8859字符串
	 * @return 转化后的字符串,失败返回null
	 */
	public static String isoToGBK(String src) {
		return charSetConvert(src, "iso-8859-1", "GBK");
	}

	/**
	 * 将GBK的字符集转换成iso8859字符集
	 * 
	 * @param src
	 *            GBK字符串
	 * @return 转化后的字符串,失败返回null
	 */
	public static String gbkToISO(String src) {
		return charSetConvert(src, "GBK", "iso-8859-1");
	}

	/**
	 * 字符替换函数 比如 String a = "ccddaa"; replace(a,"dd","xx") 将返回 ccxxaa
	 * 
	 * @param str
	 *            需要替换的原始字符串
	 * @param pattern
	 *            需要被替换掉的字符串
	 * @param replace
	 *            希望被替换成的字符串
	 * @return 返回替换后的字符串
	 */
	public static String replace(String src, String pattern, String replace) {
		int s = 0;
		int e = 0;
		StringBuffer result = new StringBuffer();
		while ((e = src.indexOf(pattern, s)) >= 0) {
			result.append(src.substring(s, e));
			result.append(replace);
			s = e + pattern.length();
		}
		result.append(src.substring(s));
		return result.toString();
	}

	/**
	 * 重复一个字符串 n 次，比如 abcabcabc
	 * 
	 * @param str
	 *            需要重复的字符串
	 * @param repeat
	 *            重复的次数
	 * @return 重复后生成的字符串
	 */
	public static String repeat(String str, int repeat) {
		StringBuffer buffer = new StringBuffer(repeat * str.length());
		for (int i = 0; i < repeat; i++) {
			buffer.append(str);
		}
		return buffer.toString();
	}

	/**
	 * 获得一个字符串的最左边的n个字符，如果长度len的长度大于字符串的总长度，返回字符串本身
	 * 
	 * @param str
	 *            原始的字符串
	 * @param len
	 *            左边的长度
	 * @return 最左边的字符
	 */
	public static String left(String str, int len) {
		if (len < 0) {
			throw new IllegalArgumentException("Requested String length " + len
					+ " is less than zero");
		}
		if ((str == null) || (str.length() <= len)) {
			return str;
		} else {
			return str.substring(0, len);
		}
	}

	/**
	 * 获得一个字符串的最右边的n个字符，如果长度len的长度大于字符串的总长度，返回字符串本身
	 * 
	 * @param str
	 *            原始的字符串
	 * @param len
	 *            右边的长度
	 * @return 最右边的字符
	 */
	public static String right(String str, int len) {
		if (len < 0) {
			throw new IllegalArgumentException("Requested String length " + len
					+ " is less than zero");
		}
		if ((str == null) || (str.length() <= len)) {
			return str;
		} else {
			return str.substring(str.length() - len);
		}
	}

	/**
	 * 将给定的字符串格式化为定长字符串, 原始字符串长度超过给定长度的,按照给定长度从左到右截取 如果原始字符串小于给定长度,
	 * 则按照给定字符在左端补足空位
	 * 
	 * @param src
	 *            原始字符串
	 * @param s2
	 *            补充用字符,
	 * @param length
	 *            格式化后长度
	 * @return 格式化后字符串
	 */
	public static String formatString(String src, char s2, int length) {
		String retValue = src;
		if (src == null || length <= 0) {
			return null;
		}

		if (src.length() > length) {
			retValue = src.substring(0, length);
		}

		for (int i = 0; i < length - src.length(); i++) {
			retValue = s2 + retValue;
		}

		return retValue;
	}

	/**
	 * 将一个浮点数转换为人民币的显示格式：￥##,###.##
	 * 
	 * @param value
	 *            浮点数
	 * @return 人民币格式显示的数字
	 */
	public static String toRMB(double value) {
		NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.CHINA);
		return nf.format(value);
	}

	/**
	 * 默认保留小数点后两位，将一个浮点数转换为定长小数位的小数 ######.##
	 * 
	 * @param value
	 *            浮点数
	 * @return 定长小数位的小数
	 */
	public static String toCurrencyWithoutComma(double value) {
		String retValue = toCurrency(value);
		retValue = retValue.replaceAll(",", "");
		return retValue;
	}

	/**
	 * 默认保留小数点后两位，将一个浮点数转换为货币的显示格式：##,###.##
	 * 
	 * @param value
	 *            浮点数
	 * @return 货币格式显示的数字
	 */
	public static String toCurrency(double value) {
		return toCurrency(value, 2);
	}

	/**
	 * 根据指定的小数位数，将一个浮点数转换为货币的显示格式
	 * 
	 * @param value
	 *            浮点数
	 * @param decimalDigits
	 *            小数点后保留小数位数
	 * @return 货币格式显示的数字 <br>
	 * <br>
	 *         例： toCurrency(123456.789,5) 将返回 "123,456.78900"
	 */
	public static String toCurrency(double value, int decimalDigits) {
		String format = "#,##0." + repeat("0", decimalDigits);
		NumberFormat nf = new DecimalFormat(format);
		return nf.format(value);

	}

	/**
	 * 将一个字符串格式化为给定的长度，过长的话按照给定的长度从字符串左边截取，反之以给定的 字符在字符串左边补足空余位 <br>
	 * 比如： prefixStr("abc",'0',5) 将返回 00aaa <br>
	 * prefixStr("abc",'0',2) 将返回 ab
	 * 
	 * @param source
	 *            原始字符串
	 * @param profix
	 *            补足空余位时使用的字符串
	 * @param length
	 *            格式化后字符串长度
	 * @return 返回格式化后的字符串,异常返回null
	 */
	public static String prefixStr(String source, char profix, int length) {
		String strRet = source;
		if (source == null) {
			return strRet;
		}
		if (source.length() >= length) {
			strRet = source.substring(0, length);
		}

		if (source.length() < length) {
			for (int i = 0; i < length - source.length(); i++) {
				strRet = "" + profix + strRet;
			}
		}

		return strRet;
	}


	/**
	 * 格式化字符串,将字符串trim()后返回. 如果字符串为null,则返回长度为零的字符串("")
	 * 
	 * @param value
	 *            被格式化字符串
	 * @return 格式化后的字符串
	 */
	public static String strObjTrim(Object value) {
		if (value == null)
			return "";
		return value.toString().trim();
	}

	/**
	 * 将一个字符串格式化为给定的长度，过长的话按照给定的长度从字符串左边截取，反之以给定的 字符在字符串右边补足空余位 <br>
	 * 比如： <br>
	 * suffixStr("abc",'0',5) 将返回 aaa00 <br>
	 * suffixStr("abc",'0',2) 将返回 ab
	 * 
	 * @param source
	 *            原始字符串
	 * @param suffix
	 *            补足空余位时使用的字符串
	 * @param length
	 *            格式化后字符串长度
	 * @return 返回格式化后的字符串,异常返回null
	 */
	public static String suffixStr(String source, char suffix, int length) {
		String strRet = source;
		if (source == null) {
			return strRet;
		}
		if (source.length() >= length) {
			strRet = source.substring(0, length);
		}

		if (source.length() < length) {
			for (int i = 0; i < length - source.length(); i++) {
				strRet += suffix;
			}
		}
		return strRet;
	}

	/**
	 * 根据分割符sp，将str分割成多个字符串，并将它们放入一个ArrayList并返回，其规则是最后的 字符串最后add到ArrayList中
	 * 
	 * @param str
	 *            被分割的字符串
	 * @param sp
	 *            分割符字符串
	 * @return 封装好的ArrayList
	 */
	public static ArrayList convertStrToArrayList(String str, String sp) {
		ArrayList al = new ArrayList();
		if (str == null) {
			return al;
		}
		String strArr[] = str.split(sp);
		for (int i = 0; i < strArr.length; i++) {
			al.add(strArr[i]);
		}

		return al;
	}

	/**
	 * 将数字字符串转换为人民币大写
	 * 
	 * @param value
	 *            金额人民币数字字符串
	 * @return 转换后的人民币大写字符串
	 */
	public static String changeToBig(String value) {

		if (null == value || "".equals(value.trim()))
			return "零";
		// add by Johnson Zhang
		int len = value.length();

		String strCheck, strArr, strFen, strDW, strNum, strBig, strNow;
		double d = 0;
		try {
			d = Double.parseDouble(value);
		} catch (Exception e) {
			return "数据" + value + "非法！";
		}

		strCheck = value + ".";
		int dot = strCheck.indexOf(".");
		if (dot > 12) {
			return "数据" + value + "过大，无法处理！";
		}

		try {
			int i = 0;
			strBig = "";
			strDW = "";
			strNum = "";

			// long intFen = (long)(d*100); //原来的处理方法
			/**
			 * 增加了对double转换为long时的精度， 例如:(long)(208123.42 * 100) = 20812341
			 * 解决了该问题
			 */
			BigDecimal big = new BigDecimal(d);
			big = big.multiply(new BigDecimal(100)).setScale(2, 4);
			long intFen = big.longValue();

			strFen = String.valueOf(intFen);
			int lenIntFen = strFen.length();
			while (lenIntFen != 0) {
				i++;
				switch (i) {
				case 1:
					strDW = "分";
					break;
				case 2:
					strDW = "角";
					break;
				case 3:
					strDW = "元";
					break;
				case 4:
					strDW = "拾";
					break;
				case 5:
					strDW = "佰";
					break;
				case 6:
					strDW = "仟";
					break;
				case 7:
					strDW = "万";
					break;
				case 8:
					strDW = "拾";
					break;
				case 9:
					strDW = "佰";
					break;
				case 10:
					strDW = "仟";
					break;
				case 11:
					strDW = "亿";
					break;
				case 12:
					strDW = "拾";
					break;
				case 13:
					strDW = "佰";
					break;
				case 14:
					strDW = "仟";
					break;
				}
				switch (strFen.charAt(lenIntFen - 1)) { // 选择数字

				case '1':
					strNum = "壹";
					break;
				case '2':
					strNum = "贰";
					break;
				case '3':
					strNum = "叁";
					break;
				case '4':
					strNum = "肆";
					break;
				case '5':
					strNum = "伍";
					break;
				case '6':
					strNum = "陆";
					break;
				case '7':
					strNum = "柒";
					break;
				case '8':
					strNum = "捌";
					break;
				case '9':
					strNum = "玖";
					break;
				case '0':
					strNum = "零";
					break;
				}
				// 处理特殊情况
				strNow = strBig;
				// 分为零时的情况
				if ((i == 1) && (strFen.charAt(lenIntFen - 1) == '0'))
					strBig = "整";
				// 角为零时的情况
				else if ((i == 2) && (strFen.charAt(lenIntFen - 1) == '0')) { // 角分同时为零时的情况
					if (!strBig.equals("整"))
						strBig = "零" + strBig;
				}
				// 元为零的情况
				else if ((i == 3) && (strFen.charAt(lenIntFen - 1) == '0'))
					strBig = "元" + strBig;
				// 拾－仟中一位为零且其前一位（元以上）不为零的情况时补零
				else if ((i < 7) && (i > 3)
						&& (strFen.charAt(lenIntFen - 1) == '0')
						&& (!("" + strNow.charAt(0)).equals("零"))
						&& (!("" + strNow.charAt(0)).equals("元")))
					strBig = "零" + strBig;
				// 拾－仟中一位为零且其前一位（元以上）也为零的情况时跨过
				else if ((i < 7) && (i > 3)
						&& (strFen.charAt(lenIntFen - 1) == '0')
						&& (("" + strNow.charAt(0)).equals("零"))) {
				}
				// 拾－仟中一位为零且其前一位是元且为零的情况时跨过
				else if ((i < 7) && (i > 3)
						&& (strFen.charAt(lenIntFen - 1) == '0')
						&& (("" + strNow.charAt(0)).equals("元"))) {
				}
				// 当万为零时必须补上万字
				// modified by Johnson Zhang
				else if ((i == 7) && (strFen.charAt(lenIntFen - 1) == '0'))
					strBig = "万" + strBig;
				// 拾万－仟万中一位为零且其前一位（万以上）不为零的情况时补零
				else if ((i < 11) && (i > 7)
						&& (strFen.charAt(lenIntFen - 1) == '0')
						&& (!("" + strNow.charAt(0)).equals("零"))
						&& (!("" + strNow.charAt(0)).equals("万")))
					strBig = "零" + strBig;
				// 拾万－仟万中一位为零且其前一位（万以上）也为零的情况时跨过
				else if ((i < 11) && (i > 7)
						&& (strFen.charAt(lenIntFen - 1) == '0')
						&& (("" + strNow.charAt(0)).equals("万"))) {
				}
				// 拾万－仟万中一位为零且其前一位为万位且为零的情况时跨过
				else if ((i < 11) && (i > 7)
						&& (strFen.charAt(lenIntFen - 1) == '0')
						&& (("" + strNow.charAt(0)).equals("零"))) {
				}
				// 万位为零且存在仟位和十万以上时，在万仟间补零
				else if ((i < 11) && (i > 8)
						&& (strFen.charAt(lenIntFen - 1) == '0')
						&& (("" + strNow.charAt(0)).equals("万"))
						&& (("" + strNow.charAt(2)).equals("仟")))
					strBig = strNum + strDW + "万零"
							+ strBig.substring(1, strBig.length());
				// 单独处理亿位
				else if (i == 11) {
					// 亿位为零且万全为零存在仟位时，去掉万补为零
					if ((strFen.charAt(lenIntFen - 1) == '0')
							&& (("" + strNow.charAt(0)).equals("万"))
							&& (("" + strNow.charAt(2)).equals("仟")))
						strBig = "亿" + "零"
								+ strBig.substring(1, strBig.length());
					// 亿位为零且万全为零不存在仟位时，去掉万
					else if ((strFen.charAt(lenIntFen - 1) == '0')
							&& (("" + strNow.charAt(0)).equals("万"))
							&& (("" + strNow.charAt(2)).equals("仟")))
						strBig = "亿" + strBig.substring(1, strBig.length());
					// 亿位不为零且万全为零存在仟位时，去掉万补为零
					else if ((("" + strNow.charAt(0)).equals("万"))
							&& (("" + strNow.charAt(2)).equals("仟")))
						strBig = strNum + strDW + "零"
								+ strBig.substring(1, strBig.length());
					// 亿位不为零且万全为零不存在仟位时，去掉万
					else if ((("" + strNow.charAt(0)).equals("万"))
							&& (("" + strNow.charAt(2)).equals("仟")))
						strBig = strNum + strDW
								+ strBig.substring(1, strBig.length());
					// 其他正常情况
					else {
						if (("" + strBig.charAt(0)).equals("万")) {
							strBig = strNum + strDW
									+ strBig.substring(1, strBig.length())
									+ " ";
						} else {
							strBig = strNum + strDW + strBig;
						}
					}

				} // 拾亿－仟亿中一位为零且其前一位（亿以上）不为零的情况时补零
				else if ((i < 15) && (i > 11)
						&& (strFen.charAt(lenIntFen - 1) == '0')
						&& (("" + strNow.charAt(0)).equals("零"))
						&& (!("" + strNow.charAt(0)).equals("亿")))
					strBig = "零" + strBig;
				// 拾亿－仟亿中一位为零且其前一位（亿以上）也为零的情况时跨过
				else if ((i < 15) && (i > 11)
						&& (strFen.charAt(lenIntFen - 1) == '0')
						&& (("" + strNow.charAt(0)).equals("亿"))) {
				}
				// 拾亿－仟亿中一位为零且其前一位为亿位且为零的情况时跨过
				else if ((i < 15) && (i > 11)
						&& (strFen.charAt(lenIntFen - 1) == '0')
						&& (("" + strNow.charAt(0)).equals("零"))) {
				}
				// 亿位为零且不存在仟万位和十亿以上时去掉上次写入的零
				else if ((i < 15) && (i > 11)
						&& (strFen.charAt(lenIntFen - 1) != '0')
						&& (("" + strNow.charAt(0)).equals("零"))
						&& (("" + strNow.charAt(1)).equals("亿"))
						&& (!("" + strNow.charAt(3)).equals("仟")))
					strBig = strNum + strDW
							+ strBig.substring(1, strBig.length());
				// 亿位为零且存在仟万位和十亿以上时，在亿仟万间补零
				else if ((i < 15) && (i > 11)
						&& (strFen.charAt(lenIntFen - 1) != '0')
						&& (("" + strNow.charAt(0)).equals("零"))
						&& (("" + strNow.charAt(1)).equals("亿"))
						&& (("" + strNow.charAt(3)).equals("仟")))
					strBig = strNum + strDW + "亿零"
							+ strBig.substring(2, strBig.length());
				else
					strBig = strNum + strDW + strBig;
				strFen = strFen.substring(0, lenIntFen - 1);
				lenIntFen--;
			}
			strBig = isoToUTF8(strBig);
			return strBig;
		} catch (Exception e) {
			return "";
		}
	}

	/**
	 * 将小写数字改成大写数字，如1变成一
	 * 
	 * @param value
	 * @return String
	 */
	public static String changeToBigdate(String value) {

		if (null == value || "".equals(value.trim())) {
			return " ";
		}

		String strDW, strNum, strNum1;

		strDW = "";
		strNum = "";
		strNum1 = "";

		for (int i = 0; i < value.length(); i++) {
			if (value.length() == 2) {
				if (i == 0) {
					switch (value.substring(0, 1).charAt(i)) {
					case '1':
						strNum = "十";
						break;
					case '2':
						strNum = "二十";
						break;
					case '3':
						strNum = "三十";
						break;
					case '0':
						strNum = " ";
						break;

					}
					switch (value.charAt(1)) { // 选择数字
					case '1':
						strNum1 = "一";
						break;
					case '2':
						strNum1 = "二";
						break;
					case '3':
						strNum1 = "三";
						break;
					case '4':
						strNum1 = "四";
						break;
					case '5':
						strNum1 = "五";
						break;
					case '6':
						strNum1 = "六";
						break;
					case '7':
						strNum1 = "七";
						break;
					case '8':
						strNum1 = "八";
						break;
					case '9':
						strNum1 = "九";
						break;
					case '0':
						strNum1 = " ";
						break;
					}

					strDW = strNum + strNum1;
				}
			}

			else {
				if (i == 0 && value.startsWith("0")) {
					strNum = "";
				} else {
					switch (value.charAt(i)) { // 选择数字
					case '1':
						strNum = "一";
						break;
					case '2':
						strNum = "二";
						break;
					case '3':
						strNum = "三";
						break;
					case '4':
						strNum = "四";
						break;
					case '5':
						strNum = "五";
						break;
					case '6':
						strNum = "六";
						break;
					case '7':
						strNum = "七";
						break;
					case '8':
						strNum = "八";
						break;
					case '9':
						strNum = "九";
						break;
					case '0':
						strNum = "零";
						break;
					}
				}
				strDW = strDW + strNum;
			}
		}

		return strDW;
	}

	/**
	 * 转换字符串 为字符串转换为Integer、Double、Long等对象去空格，如果为null或者“”转换为“0”返回 trimNumber <br>
	 * 
	 * @param str
	 * @return String
	 */
	public static String trimNumber(String str) {
		str = trim(str);
		if ("".equals(str)) {
			return "0";
		}
		return str;
	}

	/**
	 * 类型转换，使页面不显示NULL
	 * 
	 * @param s
	 * @return String
	 */
//	public static String changeString(String s) {
//		if (s.equals(null) || s.equals("") || s.equals("null")) {
//			return "";
//		} else {
//			return s.toString();
//		}
//	}

	/**
	 * 将一个字符串数组连接成字符串
	 * 
	 * @param source
	 *            需要转换的字符串数组
	 * @return
	 */
	public static String transFromArray(String[] source) {
		if (source == null || source.length < 1) {
			return null;
		}
		String result = new String();
		for (int i = 0; i < source.length; i++) {
			result += source[i];
		}
		return result;
	}
	


	/**
	 * base64编码
	 * 
	 * @param str
	 *            需要被编码的字符串
	 * @return String
	 */
	public static String encodeString(String str) {
		BASE64Encoder encoder = new BASE64Encoder();
		return encoder.encodeBuffer(str.getBytes()).trim();
	}

	/**
	 * base64解码
	 * 
	 * @param str
	 *            编码后的base64串
	 * @return String
	 */
	public static String decodeString(String str) {
	    BASE64Decoder dec = new  BASE64Decoder();
		try {
			return new String(dec.decodeBuffer(str));
		} catch (IOException io) {
			throw new RuntimeException(io.getMessage(), io.getCause());
		}
	}

	/**
	 * md5加密方法
	 * 
	 * @param s
	 *            密码字符串
	 * @return String
	 */
	public final static String MD5(String s) {
		char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
				'a', 'b', 'c', 'd', 'e', 'f' };
		try {
			byte[] strTemp = s.getBytes();
			MessageDigest mdTemp = MessageDigest.getInstance("MD5");
			mdTemp.update(strTemp);
			byte[] md = mdTemp.digest();
			int j = md.length;
			char str[] = new char[j * 2];
			int k = 0;
			for (int i = 0; i < j; i++) {
				byte byte0 = md[i];
				str[k++] = hexDigits[byte0 >>> 4 & 0xf];
				str[k++] = hexDigits[byte0 & 0xf];
			}
			return new String(str);
		} catch (Exception e) {
			log.debug("========md5加密出错=======", e);
			return null;
		}
	}

	/**
	 * 忽略大小写替换
	 * 
	 * @param regex
	 *            正则表达式
	 * @param oldStr
	 *            旧字符串
	 * @param newStr
	 *            新字符串
	 * @return
	 */
	public static String replaceIgnoreCase(String oldStr, String newStr,
			String regex) {
		Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
		Matcher m = p.matcher(oldStr);
		return m.replaceAll(newStr);
	}

	/**
	 * 将null转为空对象
	 * 
	 * @param obj
	 *            源对象
	 * @return
	 */
	public static Object convert(Object obj) {
		if (obj == null) {
			obj = "";
		}
		return obj;
	}

	/**
	 * 将null转为空对象
	 * 
	 * @param src
	 *            源字符串
	 * @return
	 */
	public static String convert(String src) {
		if (src == null) {
			src = "";
		} else {
			src = src.trim();
		}
		return src;
	}

	/**
	 * 格式化为统一的sql语句
	 * 
	 * @param sql
	 *            源sql
	 */
	public static String formatSql(String sql) {
		if (sql == null) {
			return "";
		}/* else if (sql.indexOf("'") >= 0) {
			throw new RuntimeException("sql-query sql grammar illegal");
		}*/
		String regex = "\\s+";
		sql = sql.replaceAll(regex, " ").trim().toLowerCase();
		regex = "\\s+,\\s+";
		sql = sql.replaceAll(regex, ", ");
		regex = "\\s+=\\s+";
		sql = sql.replaceAll(regex, "=");
		return sql;
	}
	
	/**
	 * 简单格式化hql
	 * @param hql
	 * @return
	 */
	public static String formatHql(String hql) {
		return mergeBlankspace(trim(hql));
	}

	public static int toNum(String src) {
		try {
			return Integer.parseInt(convert(src));
		} catch (Exception e) {
			log.debug("number format exception.");
		}
		return 0;
	}
	
	/**
	 * 格式化数字返回整数型
	 * @param  number
	 * @return int
	 */	
   public static int parseInt(String number) {
       int intNumber=0;
       try {
           intNumber=Integer.parseInt(number.trim());
       }catch(NumberFormatException err) {
       	log.debug("parseInt exception.");
       }
       
       return intNumber;
   }
	/**
	 * 格式化数字返回浮点型
	 * @param   number
	 * @return float
	 */	
   public static float parseFloat(String number) {
       float intNumber=0;
       try {
           intNumber=Integer.parseInt(number);
       }catch(NumberFormatException err) {
       	log.debug("parseFloat exception.");
       }
       
       return intNumber;
   }
	/**
	 * 格式化数字返回长整型
	 * @param   number
	 * @return long
	 */	
   public static Long parseLong(String number) {
       Long intNumber=new Long(0);
       try {
           intNumber=new Long(number);
       }catch(NumberFormatException err) {
       	log.debug("parseLong exception.");
       }
       
       return intNumber;
   }
   /**
    * 去除里面重复的字符串
    * @param changestr 字符串，字符串格式为 ",ds,fd",中间以,号隔开
    * @return String 转换好的字符串
    */
   public static String clearRepeat(String changestr){
   	String str[] = changestr.split(",");
   	Map map = new HashMap(); 
   	for(int i = 0 ; i < str.length ; i++){
   		map.put(str[i],"");    		
   	}
   	String ss ="";
   	java.util.Iterator it=map.keySet().iterator();
   	while(it.hasNext()){
   		String key=(String)it.next();
   		if(!key.equals("")){
   			ss = ss + "," + key;
   		}
   	}    
   	return ss;
   }
   
   /**
    * 将首字母转为大写
    * @param src
    * @return
    */
   public static String firstUpperCase(String src) {
   	if (isEmpty(src)) {
   		return "";
   	}
   	String pre = src.substring(0, 1).toUpperCase();
   	src = pre + src.substring(1);
   	return src;
   }
   
   /**
    * 合并空白字符
    * @param src
    * @return
    */
   public static String mergeBlankspace(String src) {
   	return src.replaceAll("\\s+", " ");
   }
   
 
   /**
    * MD5混淆加密的方法，前台统一调用此方法
    * @param str 需要加密的字符串
    * @return String 加密过的字符串
    */
   public static String encryptMD5(String str){
   	//反转过的字符串
   	String reverseStr =  reverse(str);
   	String md5Str = MD5(str+reverseStr);
   	return md5Str;
   }

   /**
    * 将正常纯文本转换成浏览器认识的html文本
    * @param src 源文件
    * @return
    */
   public static String text2Html(String src) {
    if(isBlank(src)){
    	return "";
    }
   	src = src.replaceAll("&lt;", "<");
   	src = src.replaceAll("&gt;", ">");
   	return src;
   }
   
   /**
    * 将浏览器认识的html文本转换成正常纯文本
    * @param src 源文件
    * @return
    */
   public static String html2Text(String src) {
	    if(isBlank(src)){
	    	return "";
	    }
	   	src = src.replaceAll("<", "&lt;");
	   	src = src.replaceAll(">", "&gt;");
	   	return src;
   }

   
   
   /**
    * 替换路径的间隔符号为操作系统默认的间隔符号
    * 
    * @param path
    * @return
    */
   private String convertFileSeparator(String path) {

       // if null or empty
       if (path == null || path.trim().length() < 1) {
           return "";
       }

       // replace separator
       path = path.replaceAll("\\", File.separator);
       path = path.replaceAll("/", File.separator);

       return path;
   }
   
   private static String test(String s){
   	String str[] = s.split(",");
   	Map map = new HashMap(); 
   	for(int i = 0 ; i < str.length ; i++){
   		map.put(str[i],"");    		
   	}
   	String ss ="";
   	java.util.Iterator it=map.keySet().iterator();
   	while(it.hasNext()){
   		String key=(String)it.next();
   		if(!key.equals("")){
   			ss = ss + "," + key;
   		}
   	}    
   	return ss;
   }
   /**
    * 转换字符串，如果字符串是NULL,或者“null”，或者"",统一返回""
    * @param str 需要转换的字符串
    * @return String 统一返回空字符串
    */
   public static String toString(String str){
   	if(str != null && !str.equals("") && !str.equals("null")){
   		return str;
   	}else{
   		return "";
   	}
   }
   
 
	/**
	 * 替换字符串第一个xx为空
	 * @param str 需要替换的字符串
	 * @param xx 标识符
	 * @return String 处理完的字符串
	 */
   public static String replaceFirst(String str,String xx){
   	if(str != null && !str.equals("") && !str.equals("null") && str.startsWith(xx)){
   		str  = str.replaceFirst(xx, "");
   	}
   	return str;
   }
   
   /**
    * 获取脚本
    * 如： <script type="text/javascript" src="/script/global.js"></script>
    * @param src 脚本对应的src值
    * @return
    */
   public static String getScript(String src) {
   	return new StringBuffer()
   			.append("<script type=\"text/javascript\" src=\"").append(src).append("\"></script>")
   			.toString();
   }
   
   /**
    * 数字的插入从小到大排序法，比其他算法效率高，如原来是1 3 2 9 8 10 21 5 ，排序后为1 2 3 5 8 9 10 21 
    * @param numlist 数字数组
    * @return int[] 从小到大排完序的数字数组
    */
	public static int[] insertSort(int[] numlist) {
		int in, out;
		for (out = 1; out < numlist.length; out++) {
			int temp = numlist[out];
			in = out;
			while (in > 0 && numlist[in - 1] >= temp) {
				numlist[in] = numlist[in - 1];
				--in;
			}
			numlist[in] = temp;
		}
		return numlist;
	}
	
   /**
    * 将string转换成inputstream
    * @param str
    * @return
    */
   public static InputStream String2InputStream(String str){
       ByteArrayInputStream stream = new ByteArrayInputStream(str.getBytes());
       return stream;
   }
   /**
    * 将值转换成insert sql所需要的值，增加单引号
    * @param obj
    * @return
    */
   public static String toSqlStringValue(Object obj){
   	if(obj != null && !String.valueOf(obj).equals("") && !String.valueOf(obj).equals("null")){
   		return "'"+String.valueOf(obj)+"'";
   	}
   	return null;
   }
   
   
   /**
	 * 创建指定数量的随机字符串
	 * @param numberFlag 是否是数字
	 * @param length 长度
	 * @return
	 */
	public static String createRandom(boolean numberFlag, int length){
		String retStr = "";
		String strTable = numberFlag ? NUMBER : NUMBERANTCHAR;
		int len = strTable.length();
		boolean bDone = true;
		do {
			retStr = "";
			int count = 0;
			for (int i = 0; i < length; i++) {
				double dblR = Math.random() * len;
				int intR = (int) Math.floor(dblR);
				char c = strTable.charAt(intR);
				if (('0' <= c) && (c <= '9')) {
					count++;
				}
				retStr += strTable.charAt(intR);
			}
			if (count >= 2) {
				bDone = false;
			}
		} while (bDone);
		return retStr;
	}
	
	public static boolean isEmpty(Object str) {
		return (str == null) || ("".equals(str));
	}
	
	/**
	 * 隐藏数据（1身份证号，2手机号）
	 * @param type 1： 身份证号 2：手机号 3:卡号
	 * @param data 要隐藏信息的数据
	 * @return
	 */
	public static String hideData(String type,String data){
		if("1".equals(type)){
			//身份证号
			if(data == null || data.length() != 18){
				return data;
			}
			return data.replaceAll("(\\d{6})\\d{8}(\\d{4})","$1********$2");
		}else if("2".equals(type)){
			//手机号
			if(data == null || data.length() != 11){
				return data;
			}
			return data.replaceAll("(\\d{3})\\d{4}(\\d{4})","$1****$2");
		}else if("3".equals(type)){
			//卡号
			if(data == null || data.length() < 10){
				return data;
			}
			int center = data.length() - 10;
			StringBuffer sb = new StringBuffer();
			for (int i = 0; i < center; i++) {
				sb.append("*");
			}
			return data.replaceAll("(\\d{6})\\d{"+center+"}(\\d{4})","$1"+sb.toString()+"$2");
		}else{
			return data;
		}
	}
   
   public static void main(String args[]){
	   System.out.println(encryptMD5("admin123456"));
   }
}
